package com.bds.snatch.system.util;

import org.codehaus.plexus.util.CollectionUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class RedisUtils2 {
        private static String JEDIS_IP;
        private static int JEDIS_PORT;
        private static String JEDIS_PASSWORD;
        private static JedisPool jedisPool;
        static {
            //Configuration自行写的配置文件解析类,继承自Properties
            Configuration conf=Configuration.getInstance();
            JEDIS_IP=conf.getString("jedis.ip","211.152.47.89");
            JEDIS_PORT=conf.getInt("jedis.port",6379);
            JEDIS_PASSWORD=conf.getString("jedis.password","admin123");
            JedisPoolConfig config=new JedisPoolConfig();
            config.setMaxIdle(256);
            config.setTestOnBorrow(true);
            config.setTestOnReturn(true);
            config.setTestWhileIdle(true);
            config.setMinEvictableIdleTimeMillis(60000L);
            config.setTimeBetweenEvictionRunsMillis(3000L);
            config.setNumTestsPerEvictionRun(-1);
            jedisPool=new JedisPool(config,JEDIS_IP,JEDIS_PORT,60000,JEDIS_PASSWORD);
        }
        /**
         * 获取数据
         * @param key
         * @return
         */
        public static String get(String key){
            String value=null;
            Jedis jedis=null;
            try{
                jedis=jedisPool.getResource();
                value=jedis.get(key);
            }catch (Exception e){
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            }finally {
                close(jedis);
            }
            return value;
        }

        private static void close(Jedis jedis) {
            try{
                jedisPool.returnResource(jedis);
            }catch (Exception e){
                if(jedis.isConnected()){
                    jedis.quit();
                    jedis.disconnect();
                }
            }
        }
        public static byte[] get(byte[] key){
            byte[] value = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                value = jedis.get(key);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }

            return value;
        }

        public static void set(byte[] key, byte[] value) {

            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.set(key, value);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        public static void set(byte[] key, byte[] value, int time) {

            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.set(key, value);
                jedis.expire(key, time);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        public static void hset(byte[] key, byte[] field, byte[] value) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.hset(key, field, value);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        public static void hset(String key, String field, String value) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.hset(key, field, value);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        /**
         * 获取数据
         *
         * @param key
         * @return
         */
        public static String hget(String key, String field) {

            String value = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                value = jedis.hget(key, field);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }

            return value;
        }
        /**
         * 获取数据
         *
         * @param key
         * @return
         */
        public static byte[] hget(byte[] key, byte[] field) {

            byte[] value = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                value = jedis.hget(key, field);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }

            return value;
        }
        public static void hdel(byte[] key, byte[] field) {

            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.hdel(key, field);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }
        /**
         * 存储REDIS队列 顺序存储
         * @param  key reids键名
         * @param  value 键值
         */
        public static void lpush(byte[] key, byte[] value) {

            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.lpush(key, value);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        /**
         * 存储REDIS队列 反向存储
         * @param  key reids键名
         * @param  value 键值
         */
        public static void rpush(byte[] key, byte[] value) {

            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                jedis.rpush(key, value);

            } catch (Exception e) {

                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {

                //返还到连接池
                close(jedis);

            }
        }

        /**
         * 将列表 source 中的最后一个元素(尾元素)弹出，并返回给客户端
         * @param  key reids键名
         * @param  destination 键值
         */
        public static void rpoplpush(byte[] key, byte[] destination) {

            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                jedis.rpoplpush(key, destination);

            } catch (Exception e) {

                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {

                //返还到连接池
                close(jedis);

            }
        }

        /**
         * 获取队列数据
         * @param  key 键名
         * @return
         */
        public static List lpopList(byte[] key) {

            List list = null;
            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                list = jedis.lrange(key, 0, -1);
                for(int i=0;i<list.size();i++){
                    jedis.rpop(key);
                }
            } catch (Exception e) {

                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {

                //返还到连接池
                close(jedis);

            }
            return list;
        }

        /**
         * 获取队列数据
         * @param  key 键名
         * @return
         */
        public static byte[] rpop(byte[] key) {

            byte[] bytes = null;
            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                bytes = jedis.rpop(key);

            } catch (Exception e) {

                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {

                //返还到连接池
                close(jedis);

            }
            return bytes;
        }
        public static List<byte[]> brpop(byte[] key) {
            List<byte[]> brpop = null;
            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                brpop = jedis.brpop(10,key);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {

                //返还到连接池
                close(jedis);

            }
            return brpop;
    }
        public static void hmset(Object key, Map hash) {
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.hmset(key.toString(), hash);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);

            }
        }
        public static void hmset(Object key, Map hash, int time) {
            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                jedis.hmset(key.toString(), hash);
                jedis.expire(key.toString(), time);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);

            }
        }
        public static List hmget(Object key, String... fields) {
            List result = null;
            Jedis jedis = null;
            try {

                jedis = jedisPool.getResource();
                result = jedis.hmget(key.toString(), fields);

            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);

            }
            return result;
        }

        public static Set hkeys(String key) {
            Set result = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                result = jedis.hkeys(key);

            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);

            }
            return result;
        }
        public static List lrange(byte[] key, int from, int to) {
            List result = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                result = jedis.lrange(key, from, to);

            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);

            }
            return result;
        }
        public static Map hgetAll(byte[] key) {
            Map result = null;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                result = jedis.hgetAll(key);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();

            } finally {
                //返还到连接池
                close(jedis);
            }
            return result;
        }

        public static void del(byte[] key) {

            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                jedis.del(key);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
        }

        public static long llen(byte[] key) {

            long len = 0;
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();
                len=jedis.llen(key);
            } catch (Exception e) {
                //释放redis对象
                jedisPool.returnBrokenResource(jedis);
                e.printStackTrace();
            } finally {
                //返还到连接池
                close(jedis);
            }
            return len;
        }
}
